statement: {a}+{b} ->
(+ {a} {b})

statement: {a}-{b} ->
(- {a} {b})

statement: {a}*{b} ->
(* {a} {b})

statement: {a}/{b} ->
(/ {a} {b})

statement: {a}[、{b}]+ 与 {c} 的和 ->
(+ {a} [{b}]+ {c})

statement: 创建列表 [{a}]+ ->
(list [{a}]+)

statement: 连接 {a} {b} ->
(cons {a} {b})

statement: {a} 的头 ->
(car {a})

statement: {a} 的尾 ->
(cdr {a})

statement: {a} 的第三个值 ->
(third {a})

statement: {a} 是列表？ ->
(listp {a})

statement: {a} 为空？ ->
(null {a})

statement: {a} 的否 ->
(not {a})

statement: 如果{a}，则{b}，否则{c} ->
(if {a} {b} {c})

statement: 如果{a}，则{b} ->
(if {a} {b})

statement: {a} 并且 {b} ->
(and {a} {b})

statement: {a}[、{b}]+ 并且 {c} ->
(and {a} [{b}]+ {c})

statement: {a} 或者 {b} ->
(or {a} {b})

statement: {a}[、{b}]+ 或者 {c} ->
(or {a} [{b}]+ {c})

statement: 定义  {函数} 为 [{a}]+ ->
(defun {函数} () [{a}]+)

statement: 定义 {a} 的 {函数} 为 [{b}]+ ->
(defun {函数} ({a}) [{b}]+)

statement: 定义 {a} 与 {b} 的 {函数} 为[{c}]+ ->
(defun {函数} ({a} {b}) [{c}]+)

statement: 定义 {a}[、{b}]+与{c} 的 {函数} 为[{d}]+ ->
(defun {函数} ({a} [{b}]+ {c}) [{d}]+)

statement: {函数} ->
({函数})

statement: {a} 的 {函数} ->
({函数} {a})

statement: {a} 与 {b} 的 {函数} ->
({函数} {a} {b})

statement: {a}[、{b}]+与{c} 的 {函数} ->
({函数} {a} [{b}]+ {c})

statement: {a}>{b} ->
(> {a} {b})

statement: {a}<{b} ->
(< {a} {b})

statement: 定义{a} 与 {b} 之和大于 {c} 为 {d} ->
(defun 和大于 ({a} {b} {c}) {d})

statement: {a} 与 {b} 之和大于 {c} ->
(和大于  {a} {b} {c})

statement: 定义{物品} 是否属于 {列表}为 {语句}  ->
(defun 是否属于 ({物品} {列表}) {语句})

statement: {物品} 是否属于 {列表} ->
(是否属于  {物品} {列表})

statement: {a}全等于{b} ->
(eql {a} {b})

statement: {a}等于{b} ->
(equal {a} {b})

statement: 读取输入 ->
(read)

statement: 令[{a}={b}，]+ 求[{c}]+ ->
(let ([({a} {b})]+) [{c}]+)

statement: 定义全局变量{a}为{b} ->
(defparameter {a} {b})

statement: 定义常量{a}为{b} ->
(defconstant {a} {b})

statement: {a}为全局？ ->
(boundp {a})

statement: 设{a}为{b}[，{c}为{d}]* ->
(setf {a} {b} [{c} {d}]*)

statement: 循环执行{语句}：[设{变量}的初值为{初值}，新值为{新值}；]+当{终止条件}时，{返回结果} ->
(do ([({变量} {初值} {新值})]+) ({终止条件} {返回结果}) {语句})

statement: 对于{变量}，遍历{列表}，循环执行{语句} ->
(dolist ({变量} {列表}) {语句})

statement: 格式化输出{a}，参数[{b}]+ ->
(format t {a} [{b}]+)

statement: 格式化输出{a} ->
(format nil "~%~S" {a})

statement: {a}是数值？ ->
(numberp {a})

statement: 将{函数}应用于[{列表}]+ ->
(apply {函数} [{列表}]+)

statement: 对[{参数}]+调用{函数} ->
(funcall {函数} [{参数}]+)

statement: lambda[{参数}]+：{表达式} ->
(lambda ([{参数}]+) {表达式})

statement: 函数lambda[{参数}]+：{表达式} ->
#'(lambda ([{参数}]+) {表达式})

statement: {参数}是{类型}？ ->
(typep {参数} {类型})

statement: {a}为连接对？ ->
(consp {a})

statement: {a}的拷贝 ->
(copy-list {a})

statement: {a}为原子？ ->
(atom {a})

statement: 添加列表[{a}]+ ->
(append [{a}]+)

statement: {a}为零？ ->
(zerop {a})

statement: {列表}的第{n}个元素 ->
(nth {n} {列表})

statement: {列表}的第{n}个尾 ->
(nthcdr {n} {列表})

statement: {列表}的最后一个元素 ->
(last {列表})

statement: 映射{函数}至列表[{x}]+ ->
(mapcar {函数} [{x}]+)

statement: 渐进映射{函数}至列表[{x}]+ ->
(maplist {函数} [{x}]+)

statement: 将序列{list}中的{x}替换为{y} ->
(substitute {y} {x} {list})

statement: 将树{tree}中的{x}替换为{y} ->
(subst {y} {x} {tree})

statement: 加入{元素}到集合{set} ->
(adjoin {元素} {set})

statement: {a}与{b}的并集 ->
(union {a} {b})

statement: {a}与{b}的交集 ->
(intersection {a} {b})

statement: {a}与{b}的补集 ->
(set-difference {a} {b})

statement: {a}的长度 ->
(length {a})

statement: {a}的长度 ->
(length {a})

statement: 序列{a}从{start}到{end}的子序列 ->
(subseq {a} {start} {end})

statement: 序列{a}从{start}到末尾的子序列 ->
(subseq {a} {start})

statement: 反转序列{a} ->
(reverse {a})

statement: {n}为偶数？ ->
(evenp {n})

statement: 应用{函数}对{序列}进行排序 ->
(sort {序列} {函数})

statement: 将{a}入栈{stack} ->
(push {a} {stack})

statement: 出栈{stack} ->
(pop {stack})

statement: {列表}中{sym}的关联  ->
(assoc {sym} {列表})

statement: 数值{vec}中的第{n}个元素 ->
(aref {vec} {n})

statement: {a}的四舍五入 ->
(round {a})

statement: {a}不全等于{b} ->
(not (eql {a} {b}))

